﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;


namespace Atentis_Connector
{
	public class MoneyControl
	{
		private string m_SecCode;
		/// <summary>
		/// Код бумаги
		/// </summary>
		public string SecCode { get { return m_SecCode; } set { m_SecCode = value; } }
        
		/// <summary>Приказ покупки по рынку, бумага, кол-во</summary>
		public event Action<string, int> e_BuyMarket;
		/// <summary>Приказ продажи по рынку, бумага, кол-во</summary>
		public event Action<string, int> e_SellMarket;
        
		/// <summary>Приказ покупки по цене, бумага, кол-во, цена</summary>
		public event Action<string, int, double> e_BuyLimit;
		/// <summary>Приказ продажи по цене, бумага, кол-во, цена</summary>
		public event Action<string, int, double> e_SellLimit;

		/// <summary>Событие-извещение</summary>
		public event Action<string> e_AddToLog;
		/// <summary>Приказ снять все заявки</summary>
		public event Action e_KillAllOrders;
		/// <summary>Приказ снять одну заявку</summary>
		public event Action<long> e_KillOrder;

		public event Action<string> e_LogStateChange;
		public event Action<string> e_LogPositionChange;
		public event Action<string> e_LogPriceOpenPositionChange;
		public event Action<string> e_LogPriceClosePositionChange;
		public event Action<string> e_LogPriceLastStepPriceChange;

		/// <summary> Список неподтвержденных ордеров</summary>
		List<double> l_noExecuteOrders = new List<double>();
		/// <summary> Список завершенных сделок на покупку</summary>
		List<double> l_buyTrades = new List<double>();
		/// <summary> Список совершенных сделок на продажу</summary>
		List<double> l_sellTrades = new List<double>();

		/// <summary> Все возможные состояния</summary>
		public enum en_State
		{
			CloseLong,
			CloseShort,
			OpenLong,
			OpenShort,
			PartialBuy,
			PartialSell,
			Wait,
			Translation
		}

		/// <summary>Текущее состояние</summary>
		en_State currentState = en_State.Wait;

		/// <summary>Заданный профит для лимитированной торговли</summary>
		public double p_Profit = 10;
		/// <summary>Допустимый убыток для лимитированной торговли</summary>
		public double p_Loss = 10;
		/// <summary>Уровень начала слежения ДТ</summary>
		public int p_DeltaProfitLine = 10;
		/// <summary>Допустимая просадка в пунктах от максимального
		/// профита за период от сделки до момента наступления просадки
		/// По наступлении - закрываем сделку. </summary>
		public int p_DeltaProfit = int.MaxValue / 2;
		/// <summary>Объем заявки для лимитированной торговли</summary>
		public int p_Volume = 1;
		/// <summary>Кол-во пунктов движения цены в нужную сторону после выхода из сделки для повторного входа</summary>
		public int p_ReturnSlide = 2;
		/// <summary>Текущая позиция </summary>
		public int p_currentPosition = 0;
		/// <summary>Прогнозируемая позиция </summary>
		int p_positionPrognoz = 0;
		/// <summary>Количество ступеней </summary>
		public int p_StepCount = 1;
		/// <summary>Объем 1 ступени </summary>
		public int p_StepVolume = 0;
		/// <summary>Расстояние между ступенями </summary>
		public int p_StepDelta = 0;

		/// <summary>Средняя цена входа в позицию </summary>
		double PriceOpenPosition = 0;
		/// <summary>Средняя цена выхода из позиции </summary>
		double PriceClosePosition = 0;
		/// <summary>Последняя поступившая цена</summary>
		double LastPrice = 0;
		/// <summary>Последняя цена ступени</summary>
		double LastStepPrice = 0;
		/// <summary>Последняя контрольная цена ступени</summary>
		double LastAlertPrice = 0;
		/// <summary> Режим торговли. True - простой, False - ступенями </summary>
		private bool b_SimpleOrStepMode = true;
		private bool b_CanEnableInStepTrading = true;

		private bool b_HaveProfitLong = false;
		private bool b_HaveProfitShort = false;

		private bool b_DeltaTradingEnabled = false;
		private bool b_ReturnTradingEnabled = false;

		private bool b_mustBuy = false;
		private bool b_mustSell = false;

		/// <summary>
		/// Последнее (текущее) состояние
		/// </summary>
		private bool? b_lastStateLong = null;

		double max = double.MinValue;
		double min = double.MaxValue;

		Object locker = new Object();

		/// <summary>
		/// Включение дельта-трейдинга
		/// </summary>
		public void F_EnableDT()
		{
			b_DeltaTradingEnabled = true;
		}
		/// <summary>
		/// Отключение дельта-трейдинга
		/// </summary>
		public void F_DisableDT()
		{
			b_DeltaTradingEnabled = false;
		}
		/// <summary>
		/// Включение возвратного трейдинга
		/// </summary>
		public void F_EnableRT()
		{
			b_ReturnTradingEnabled = true;
		}
		/// <summary>
		/// Выключение возвратного трейдинга
		/// </summary>
		public void F_DisableRT()
		{
			b_ReturnTradingEnabled = false;
		}
		/// <summary>
		/// Включение торговли ступенями
		/// </summary>
		public void F_EnableST()
		{
			b_SimpleOrStepMode = false;
		}
		/// <summary>
		/// Выключение торговли ступенями
		/// </summary>
		public void F_DisableST()
		{
			b_SimpleOrStepMode = true;
		}

		/// <summary> Получен новый неисполненный ордер</summary>
		public void F_SetNewNoExecuteOrder(double AlorId)
		{
			this.l_noExecuteOrders.Add(AlorId);
		}
		/// <summary> Получен исполненный ордер</summary>
		public void F_SetExecuteOrder(double AlorId)
		{
			this.l_noExecuteOrders.Remove(AlorId);
		}

		/// <summary> Обновлена позиция по активной бумаге</summary>
		public void F_SetPosition(int Count)
		{
			this.p_currentPosition = Count;
			if (e_LogPositionChange != null)
				e_LogPositionChange(Count.ToString());

			//if (Count > Math.Abs(positionAlor)) { Console.Beep(440, 300); }
			if (p_positionPrognoz == 0)
			{
				//f_SetState(en_State.Wait); 
				PriceOpenPosition = 0;
				PriceClosePosition = 0;
				if (b_lastStateLong == true)
				{
					currentState = en_State.CloseLong;
				}
				if (b_lastStateLong == false)
				{
					currentState = en_State.CloseShort;
				}
			}
		}


		/// <summary> Получена новая собственная сделка на покупку</summary>
		public void F_NewBuyTrade(int Volume, double Price)
		{
			lock (locker)
			{
				f_AddToLog("Получена новая сделка на покупку по цене" + Price);
				p_positionPrognoz = p_positionPrognoz + Volume;
				//Если включена простая торговля
				if (b_SimpleOrStepMode)
				{
					if (currentState == en_State.OpenLong || currentState == en_State.Wait)//Если текущий статус - в лонге или не в позиции
					{
						if (PriceOpenPosition == 0)//Проверяем среднюю цену позиции, если она О, т.е. это первый вход
						{
							PriceOpenPosition = Price; //Устанавливаем среднюю цену равной цене первой сделки
							f_SetPriceOpenPosition(); //Сообщаем об этом форме
						}
						else //Если цена позиции не ноль, т.е. мы докупаемся
						{
							PriceOpenPosition = ((l_buyTrades.Count * PriceClosePosition + Volume * Price) / (l_buyTrades.Count + Volume)); //Расчитываем среднюю цену заново
							f_SetPriceOpenPosition(); //Сообщаем об этом форме
						}
						if (!b_DeltaTradingEnabled) //Если дельта трейдинг выключен
						{
							if (e_SellLimit != null) { e_SellLimit(SecCode, Volume, Price + p_Profit); } //Сразу выставляем встречную закрывающую лимитированную заявку
						}
					}

					if (currentState != en_State.OpenLong && currentState != en_State.Wait) //Если текущий статус не в лонге и не в позиции
					{
						b_lastStateLong = false; //Изменяем флаг последнего состояния
						if (PriceClosePosition == 0) //Если цена выхода из позиции равна 0
						{
							PriceClosePosition = Price;//Устанавливаем среднюю цену равной цене первой сделки
							f_SetPriceClosePosition();//Сообщаем об этом форме
						}
						else
						{
							PriceClosePosition = ((l_sellTrades.Count * PriceClosePosition + Volume * Price) / (l_sellTrades.Count + Volume));//Расчитываем среднюю цену заново
							f_SetPriceClosePosition();//Сообщаем об этом форме
						}
					}
				}

				//Если включена торговля ступенями
				if (!b_SimpleOrStepMode)
				{
					if (currentState == en_State.OpenLong)//Если текущий статус - в лонге
					{
						LastStepPrice = Price; //Устанавливаем среднюю цену равной цене сделки
						LastAlertPrice = Price + p_StepDelta;
						b_CanEnableInStepTrading = true;
					}
				}

				//Добавляем сделки в лист сделок
				for (int i = 0; i < Volume; i++)
				{
					l_buyTrades.Add(Price);
				}
				f_AddToLog("Средняя цена позиции равна " + PriceOpenPosition);
				f_SetPriceOpenPosition();//Сообщаем об этом форме
			}
		}

		/// <summary> Получена новая собственная сделка на продажу</summary>
		public void F_NewSellTrade(int Volume, double Price)
		{
			//КОММЕНТАРИИ АНАЛОГИЧНЫ В МЕТОДЕ ВЫШЕ
			lock (locker)
			{
				p_positionPrognoz = p_positionPrognoz - Volume;
				f_AddToLog("Получена новая сделка на продажу по цене" + Price);
				if (b_SimpleOrStepMode)
				{
					if (currentState == en_State.OpenShort || currentState == en_State.Wait)
					{
						if (PriceOpenPosition == 0)
						{
							PriceOpenPosition = Price;
							f_SetPriceOpenPosition();
						}
						else
						{
							PriceOpenPosition = ((l_sellTrades.Count * PriceOpenPosition + Volume * Price) / (l_sellTrades.Count + Volume));
							f_SetPriceOpenPosition();
						}
						if (!b_DeltaTradingEnabled)
						{
							if (e_BuyLimit != null) { e_BuyLimit(SecCode, Volume, Price - p_Profit); }
						}
					}

					if (currentState != en_State.OpenShort && currentState != en_State.Wait)
					{
						b_lastStateLong = true;
						if (PriceClosePosition == 0)
						{
							PriceClosePosition = Price;
							f_SetPriceClosePosition();
						}
						else
						{
							PriceClosePosition = ((l_sellTrades.Count * PriceOpenPosition + Volume * Price) / (l_sellTrades.Count + Volume));
							f_SetPriceClosePosition();
						}
					}
				}

				if (!b_SimpleOrStepMode)
				{
					if (currentState == en_State.OpenShort)//Если текущий статус - в шорте
					{
						LastStepPrice = Price; //Устанавливаем среднюю цену равной цене первой сделки   
						LastAlertPrice = Price - p_StepDelta;
						b_CanEnableInStepTrading = true;
					}
				}
				for (int i = 0; i < Volume; i++)
				{
					l_sellTrades.Add(Price);
				}
				f_AddToLog("Средняя цена позиции равна " + PriceOpenPosition);
				f_SetPriceOpenPosition();
			}
		}
		/// <summary>
		/// Контрольная цена 1 для отсева адресных сделок
		/// </summary>
		double currentPrice1 = 0;
		/// <summary>
		/// Контрольная цена 2 для отсева адресных сделок
		/// </summary>
		double currentPrice2 = 0;

		/// <summary>Получена новая сделка по активной бумаге</summary>
		/// <param name="currentPrice">Цена полученной сделки</param>
		public void F_SetTrade(double currentPrice)
		{
			this.LastPrice = currentPrice;
			currentPrice2 = currentPrice1;
			currentPrice1 = currentPrice;
			lock (locker)
			{
				//Если мы в позиции
				if (p_currentPosition != 0)
				{
					//В зависимости от текущего состояния
					switch (currentState)
					{
						case en_State.OpenLong:
							if (b_SimpleOrStepMode)//Если включен режим простой торговли
							{
								//Если превышен убыток закрываем позицию
								if ((PriceOpenPosition - currentPrice > p_Loss) &&
									(PriceOpenPosition - currentPrice1 > p_Loss) &&
									(PriceOpenPosition - currentPrice2 > p_Loss))
								{
									f_AddToLog("МС. Выход из лонга по лоссу");
									f_ClosePosition();

									break;
								}

								//Дельта трейдинг
								if (b_DeltaTradingEnabled)
								{
									//Если прошли линию профита, выставляем флаг об этом
									if ((currentPrice - PriceOpenPosition > p_Profit) &&
										(currentPrice1 - PriceOpenPosition > p_Profit) &&
										(currentPrice2 - PriceOpenPosition > p_Profit))
									{ b_HaveProfitLong = true; }

									//Если профит стал меньше возможного после прохождения границы профита - выходим
									if (((currentPrice - PriceOpenPosition < p_Profit) && (b_HaveProfitLong)) &&
										((currentPrice1 - PriceOpenPosition < p_Profit) && (b_HaveProfitLong)) &&
										((currentPrice2 - PriceOpenPosition < p_Profit) && (b_HaveProfitLong)))
									{
										f_AddToLog("МС. Выход из лонга по профиту");
										f_ClosePosition();
									}

									//Если превышена дельта
									if (((currentPrice > PriceOpenPosition) && (currentPrice - PriceOpenPosition >= p_DeltaProfitLine)) &&
										((currentPrice1 > PriceOpenPosition) && (currentPrice1 - PriceOpenPosition >= p_DeltaProfitLine)) &&
										((currentPrice2 > PriceOpenPosition) && (currentPrice2 - PriceOpenPosition >= p_DeltaProfitLine)))
									{
										if (currentPrice > max) { max = currentPrice; }
										if (currentPrice < max - p_DeltaProfit) { f_ClosePosition(); }
									}
								}
							}
							else //Если включен режим торговли ступенями 
							{
								if (LastStepPrice != 0)
								{
									if ((currentPrice > LastAlertPrice) &&//Прошли порог входа еще на ступень
									  (currentPrice1 > LastAlertPrice) &&
									  (currentPrice2 > LastAlertPrice))
									{
										f_OpenPosition(true);//Докупаемся на еще одной ступени
										LastAlertPrice = LastStepPrice + p_StepDelta;
									}

									if ((currentPrice < LastStepPrice - p_Loss) &&//Прошли порог убытка
										(currentPrice1 < LastStepPrice - p_Loss) &&
										(currentPrice2 < LastStepPrice - p_Loss))
									{
										f_ClosePosition();//Полностью закрываем позицию
									}

									if ((currentPrice > LastStepPrice + p_Profit) &&//Прошли порог абсолютного профита (т.е. нет объема для ступеней)
										(currentPrice1 > LastStepPrice + p_Profit) &&
										(currentPrice2 > LastStepPrice + p_Profit))
									{
										f_ClosePosition();
									}
								}

							}
							break;
						case en_State.OpenShort:
							if (b_SimpleOrStepMode)//Если включен режим простой торговли
							{
								//Если превышен убыток закрываем позицию
								if ((currentPrice - PriceOpenPosition > p_Loss) &&
									(currentPrice1 - PriceOpenPosition > p_Loss) &&
									(currentPrice2 - PriceOpenPosition > p_Loss))
								{
									f_AddToLog("МС. Выход из шорта по лоссу");
									f_ClosePosition();
								}

								//Дельта трейдинг
								if (b_DeltaTradingEnabled)
								{
									//Если прошли линию профита, выставляем флаг об этом
									if ((PriceOpenPosition - currentPrice > p_Profit) &&
										(PriceOpenPosition - currentPrice1 > p_Profit) &&
										(PriceOpenPosition - currentPrice2 > p_Profit))
									{ b_HaveProfitShort = true; }

									//Если профит стал меньше возможного после прохождения границы профита - выходим
									if (((PriceOpenPosition - currentPrice < p_Profit) && (b_HaveProfitShort)) &&
									   ((PriceOpenPosition - currentPrice1 < p_Profit) && (b_HaveProfitShort)) &&
									   ((PriceOpenPosition - currentPrice2 < p_Profit) && (b_HaveProfitShort)))
									{
										f_AddToLog("МС. Выход из шорта по профиту");
										f_ClosePosition();
									}

									//Если превышена дельта
									if (((currentPrice < PriceOpenPosition) && (PriceOpenPosition - currentPrice >= p_Profit + p_DeltaProfitLine)) &&
										((currentPrice1 < PriceOpenPosition) && (PriceOpenPosition - currentPrice1 >= p_Profit + p_DeltaProfitLine)) &&
										((currentPrice2 < PriceOpenPosition) && (PriceOpenPosition - currentPrice2 >= p_Profit + p_DeltaProfitLine)))
									{
										if (currentPrice < min) { min = currentPrice; }
										if (currentPrice > min + p_DeltaProfit) { f_ClosePosition(); }
									}
								}
								else
								{

								}
							}
							else //Если включен режим торговли ступенями
							{
								if (LastStepPrice != 0)
								{
									if ((currentPrice < LastAlertPrice) &&//Прошли порог входа еще на ступень
									  (currentPrice1 < LastAlertPrice) &&
									  (currentPrice2 < LastAlertPrice))
									{
										f_OpenPosition(false);//Докупаемся на еще одной ступени
										LastAlertPrice = LastStepPrice - p_StepDelta;
									}

									if ((currentPrice > LastStepPrice + p_Loss) &&//Прошли порог убытка
										(currentPrice1 > LastStepPrice + p_Loss) &&
										(currentPrice2 > LastStepPrice + p_Loss))
									{
										f_ClosePosition();//Полностью закрываем позицию
									}

									if ((currentPrice < LastStepPrice - p_Profit) &&//Прошли порог абсолютного профита (т.е. нет объема для ступеней)
										(currentPrice1 < LastStepPrice - p_Profit) &&
										(currentPrice2 < LastStepPrice - p_Profit))
									{
										f_ClosePosition();
									}
								}
							}
							break;
					}
				}

				//Если мы не в позиции
				else
				{
					if (b_ReturnTradingEnabled)//Если включен возвратный трейдинг
					{
						switch (currentState)
						{
							case en_State.CloseLong:
								if (l_sellTrades.Count != 0)//Если уже были сдлеки на продажу, т.е. было закрытие лонга
								{
									if ((currentPrice >= l_sellTrades.Last() + p_ReturnSlide) &&//Если цена ушла достаточно, входим в лонг
										(currentPrice1 >= l_sellTrades.Last() + p_ReturnSlide) &&
										(currentPrice2 >= l_sellTrades.Last() + p_ReturnSlide))
									{
										f_AddToLog("МС. Вход в лонг по РТ");
										f_OpenPosition(true);

									}
								}
								break;
							case en_State.CloseShort:
								if (l_buyTrades.Count != 0) //Если же были сдлеки на покупку. т.е. было закрытие лонга
								{
									if ((currentPrice >= l_buyTrades.Last() + p_ReturnSlide) &&//Если цена ушла достаточно, входим в шорт
										(currentPrice1 >= l_buyTrades.Last() + p_ReturnSlide) &&
										(currentPrice2 >= l_buyTrades.Last() + p_ReturnSlide))
									{
										f_AddToLog("МС. Вход в шорт по РТ");
										f_OpenPosition(false);
									}
								}
								break;
						}
					}
					if (b_mustBuy == true) //если было желание покупки
					{
						b_mustBuy = false;
						f_OpenPosition(true); //покупаем
					}
					if (b_mustSell == true) //если было желание продажи
					{
						b_mustSell = false;
						f_OpenPosition(false); //продаем
					}
				}
			}
		}

        double m_BuyPrice = 0;
        /// <summary> Получен приказ на покупку от стратегии</summary>
		public void F_Buy(double price)
		{
			lock (locker)
			{
                m_BuyPrice = price;
				if (p_currentPosition == 0 && currentState != en_State.OpenLong)
				{
					f_OpenPosition(true);
				}
				else if (p_currentPosition < 0 && currentState != en_State.OpenLong)
				{
					f_ClosePosition();
					b_mustBuy = true;
				}
				else if (p_currentPosition > 0)
				{

				}
			}
		}

        double m_SellPrice = 0;
		/// <summary> Получен приказ на продажу от стратегии</summary>
		public void F_Sell(double price)
		{
			lock (locker)
			{
                m_SellPrice = price;
				if (p_currentPosition == 0 && currentState != en_State.OpenShort)
				{
					f_OpenPosition(false);
				}
				else if (p_currentPosition < 0)
				{

				}
				else if (p_currentPosition > 0 && currentState != en_State.OpenShort)
				{
					f_ClosePosition();
					b_mustSell = true;
				}
			}
		}

		/// <summary>
		/// Установка настроек
		/// </summary>
		/// <param name="Profit">Профит в пунктах</param>
		/// <param name="Loss">Лось в пунктах</param>
		/// <param name="DeltaProfit">Дельта профит в процентах</param>
		/// <param name="ReturnSlide">Дельта возврата в пунктах</param>
		/// <param name="Volume">Объем для торговли, контрактов</param>
		public void F_SetSettings(double Profit, double Loss, int DeltaProfitLine, int DeltaProfit, int ReturnSlide, int Volume, int StepVolume, int StepCount, int StepDelta)
		{
			p_Profit = Profit;
			p_Loss = Loss;
			p_DeltaProfitLine = DeltaProfitLine;
			p_DeltaProfit = DeltaProfit;
			p_ReturnSlide = ReturnSlide;
			p_StepVolume = StepVolume;
			p_StepCount = StepCount;
			p_StepDelta = StepDelta;
			p_Volume = Volume;
			f_AddToLog("МС. Настройки установлены");
		}

		/// <summary> Открытие позиции</summary> <param name="buySell">true - лонг, false - шорт</param>
		void f_OpenPosition(bool buySell)
		{
			lock (locker)
			{
				if (!b_SimpleOrStepMode && b_CanEnableInStepTrading)
				{
					if (buySell == true)
					{
						f_SetState(en_State.OpenLong);
						b_CanEnableInStepTrading = false;
						//e_BuyMarket(SecCode, this.p_StepVolume);
                        if (m_BuyPrice > 0)
                        e_BuyLimit(SecCode, this.p_StepVolume, m_BuyPrice);
					}
					else
					{
						f_SetState(en_State.OpenShort);
						b_CanEnableInStepTrading = false;
						//e_SellMarket(SecCode, this.p_StepVolume);
                        if (m_SellPrice > 0)
                        e_SellLimit(SecCode, this.p_StepVolume, m_SellPrice);
					}
				}

				if (b_SimpleOrStepMode)
				{
					if (buySell == true && currentState != en_State.OpenLong)
					{
						f_SetState(en_State.OpenLong);
						//e_BuyMarket(SecCode, this.p_Volume);
                        if (m_BuyPrice > 0)
                        e_BuyLimit(SecCode, this.p_Volume, m_BuyPrice);
					}
					else if (buySell == false && currentState != en_State.OpenShort)
					{
						f_SetState(en_State.OpenShort);
						//e_SellMarket(SecCode, this.p_Volume);
                        if (m_SellPrice>0)
                        e_SellLimit(SecCode, this.p_Volume, m_SellPrice);
					}
				}
			}
		}

		/// <summary>Закрытие позиции</summary>
		void f_ClosePosition()
		{
			lock (locker)
			{
				if (p_currentPosition > 0 && currentState != en_State.CloseLong)
				{
					f_SetState(en_State.CloseLong);
					e_SellMarket(SecCode, Math.Abs(p_currentPosition));
					f_AddToLog("МС. Закрытие лонга в кол-ве " + (Math.Abs(p_currentPosition)).ToString());
				}
				else if (p_currentPosition < 0 && currentState != en_State.CloseShort)
				{
					f_SetState(en_State.CloseShort);
					e_BuyMarket(SecCode, Math.Abs(p_currentPosition));
					f_AddToLog("МС. Закрытие шорта в кол-ве " + (Math.Abs(p_currentPosition)).ToString());
				}

				PriceOpenPosition = 0;

				b_HaveProfitLong = false;
				b_HaveProfitShort = false;
				b_CanEnableInStepTrading = true;

				e_KillAllOrders();
			}
		}

		void f_SetPriceOpenPosition()
		{
			if (e_LogPriceOpenPositionChange != null)
				e_LogPriceOpenPositionChange(PriceOpenPosition.ToString());
		}

		void f_SetPriceClosePosition()
		{
			if (e_LogPriceClosePositionChange != null)
				e_LogPriceClosePositionChange(PriceClosePosition.ToString());
		}

		void f_SetPriceLastStep()
		{

		}

		/// <summary>Установка текущего состояния</summary>
		void f_SetState(en_State NewState)
		{
			this.currentState = NewState;
			f_AddToLog("МС. Статус изменен на " + NewState.ToString());
			if (e_LogStateChange != null)
				e_LogStateChange(NewState.ToString());
		}

		/// <summary>Запись в лог</summary>
		void f_AddToLog(string TextToLog)
		{
			if (e_AddToLog != null)
			{
				e_AddToLog(TextToLog);//+ " AveragePrice=" +AveragePrice.ToString() + " CurrentPrice="+LastPrice.ToString() + " Position="+_position.ToString() );
			}
		}

	}
}
